//#include <stm32f4xx.h>        // STM32F4系列芯片外设库
//#include <includes.h>         // 通用头文件（包含类型定义等）
//#include <stdio.h>            // 标准输入输出函数
//#include <string.h>           // 字符串处理函数

//#include <lvgl.h>             // LVGL图形库核心头文件
//#include <lv_port_disp.h>     // LVGL显示接口适配
//#include <lv_port_indev.h>    // LVGL输入设备（触摸屏）适配
//#include <lv_demo_widgets.h>  // LVGL控件示例
//#include <touch.h>            // 触摸屏驱动

//#include <FreeRTOS.h>         // FreeRTOS实时操作系统核心
//#include <task.h>             // FreeRTOS任务管理
//#include <semphr.h>           // FreeRTOS信号量/互斥锁
//#include <event_groups.h>     // FreeRTOS事件组（未使用）
//#include <queue.h>            // FreeRTOS消息队列
//#include <timers.h>           // FreeRTOS软件定时器（未使用）

//#include <ui.h>               // 自定义UI界面头文件

//// 消息队列大小（可存储4条消息）
//#define QUEUE_SIZE 4

//// 声明自定义字体（LVGL使用）
//LV_FONT_DECLARE(my_font);

//// 锁操作状态标志（0：空闲；1：正在执行开锁）
//volatile uint8_t g_lock_operating = 0;  

//// -------------------------- 卡片管理相关宏定义 --------------------------
//#define CARD_NUM         5       // 最大注册卡数量
//#define CARD_SIZE        6       // 每张卡存储大小（1字节前缀+5字节卡号）
//#define CARD_ADDR        0x00000 // 卡片数据在Flash中的起始存储地址

//// -------------------------- 密码管理相关宏定义 --------------------------
//#define PASSWORD_ADDR    0x01000 // 密码在Flash中的存储地址（与卡号地址不冲突）
//#define PASSWORD_LENGTH  6       // 密码长度（6位数字）
//#define DEFAULT_PASSWORD "000000" // 默认初始密码

//// -------------------------- 手机号码管理相关宏定义 --------------------------
//#define PHONE_NUMBER_ADDR 0x02000  // 手机号码在Flash中的存储地址
//#define PHONE_LENGTH      11       // 手机号码长度（11位数字）
//#define DEFAULT_PHONE     "15207640967" // 默认初始手机号码

//// -------------------------- 全局变量定义 --------------------------
//char current_phone_number[PHONE_LENGTH + 1]; // 当前手机号码缓冲区（+1用于字符串结束符）

//// 系统模式定义（验证/注册/清空）
//#define MODE_VERIFY      0       // 验证模式（默认）：验证卡片/指纹合法性
//#define MODE_REGISTER    1       // 注册模式：新增卡片/指纹
//#define MODE_CLEAR       2       // 清空模式：删除所有已注册卡片/指纹

//// -------------------------- 指纹模块相关变量 --------------------------
//SysPara AS608Para;       // 指纹模块AS608的系统参数（容量/安全等级等）
//u16 ValidN;              // 模块内已存储的有效指纹个数

//// 全局变量
//volatile uint8_t g_mode = MODE_VERIFY;   // 默认进入验证模式
//uint8_t current_password[PASSWORD_LENGTH + 1]; // 当前密码缓冲区（+1用于结束符）
//uint8_t card_type[2];           // 卡类型缓冲区（RC522读取）
//uint8_t card_id[6];             // 卡号缓冲区（包含校验位，共6字节）
//uint8_t record_card[6];         // 从Flash读取的已存储卡号缓冲区

//// FreeRTOS任务句柄（用于任务创建和管理）
//TaskHandle_t app_task_init_handle  = NULL;  // 初始化任务句柄
//TaskHandle_t app_task_1_handle     = NULL;  // 任务1句柄（天气切换）
//TaskHandle_t app_task_2_handle     = NULL;  // 任务2句柄（环境监测）
//TaskHandle_t app_task_3_handle     = NULL;  // 任务3句柄（卡片识别）
//TaskHandle_t app_task_4_handle     = NULL;  // 任务4句柄（蓝牙控制）
//TaskHandle_t app_task_5_handle     = NULL;  // 任务5句柄（LVGL界面）
//TaskHandle_t app_task_6_handle     = NULL;  // 任务6句柄（433M开锁）

//// 消息队列句柄（用于蓝牙指令接收）
//QueueHandle_t usart_queue = NULL;

//// 二值信号量句柄（433M模块触发开锁信号）
//SemaphoreHandle_t  lock_433m_sem_exit;

//// 互斥锁句柄（保护共享资源访问）
//SemaphoreHandle_t oled_mutex;      // OLED显示互斥锁（防止多任务同时操作屏幕）
//SemaphoreHandle_t vibrate_mutex;   // 震动传感器互斥锁（防止报警冲突）

//// -------------------------- 任务函数声明 --------------------------
//void app_task_init(void *pvParameters);   // 初始化任务
//void app_task_1(void *pvParameters);     // 天气切换与模式控制任务
//void app_task_2(void *pvParameters);     // 环境监测任务
//void app_task_3(void *pvParameters);     // 卡片识别与管理任务
//void app_task_4(void *pvParameters);     // 蓝牙指令处理任务
//void app_task_5(void *pvParameters);     // LVGL界面刷新任务
//void app_task_6(void *pvParameters);     // 433M无线开锁任务

//// -------------------------- 卡片模式设置函数 --------------------------
///**
// * @brief  设置卡片操作模式（验证/注册/清空）
// * @param  mode：目标模式（MODE_VERIFY/MODE_REGISTER/MODE_CLEAR）
// * @note   使用临界区保护全局变量g_mode，防止多任务并发修改
// */
//void set_card_mode(uint8_t mode) {
//    taskENTER_CRITICAL();  // 进入临界区（关闭任务调度）
//    g_mode = mode;         // 修改模式
//    taskEXIT_CRITICAL();   // 退出临界区（恢复任务调度）
//}

//// -------------------------- 指纹识别相关函数 --------------------------
///**
// * @brief  刷指纹验证函数
// * @return 1：验证成功；0：验证失败；2：无手指按压
// * @note   流程：获取指纹图像→生成特征→与库中特征比对
// */
//uint8_t press_FR(void)
//{
//    SearchResult seach;  // 指纹搜索结果（包含ID和匹配得分）
//    u8 ensure;           // 指纹模块返回状态码
//    char str[64];        // 调试信息缓冲区
//    
//    ensure = PS_GetImage();  // 获取指纹图像
//    if(ensure == 0x00)       // 获取图像成功 
//    {    
//        printf("获取图像成功\r\n");
//        ensure = PS_GenChar(CharBuffer1);  // 生成指纹特征（存入缓冲区1）
//        if(ensure == 0x00)                 // 生成特征成功
//        {        
//            printf("生成特征成功\r\n");
//            // 高速搜索指纹库（从缓冲区1匹配，搜索范围0~最大容量）
//            ensure = PS_HighSpeedSearch(CharBuffer1, 0, AS608Para.PS_max, &seach);
//            if(ensure == 0x00)  // 搜索成功（找到匹配指纹）
//            {                
//                printf("搜索成功\r\n");
//                sprintf(str, "确有此人,ID:%d  匹配得分:%d", seach.pageID, seach.mathscore);
//                printf("%s\r\n", str);
//                return 1;  // 验证成功
//            }
//            else 
//            {
//                printf("搜索失败\r\n");
//                return 0;  // 验证失败
//            }        
//        }
//        else
//        {
//            printf("生成特征失败\r\n");
//            return 0;  // 验证失败
//        }        
//    }
//    else if(ensure == 0x02) 
//    {
//        // 传感器上没有手指，不视为错误
//        return 2;  
//    }
//    else
//    {
//        printf("获取图像失败: %s\r\n", EnsureMessage(ensure));
//        return 0;  // 验证失败
//    }
//    
//    delay_ms(600);
//    return 0;
//}

///**
// * @brief  注册新指纹到指定ID
// * @param  pageID：指纹存储ID（0~最大容量）
// * @note   流程：两次采集指纹→生成模板→存储到模块
// */
//void register_FR(u16 pageID)
//{
//    u8 ensure;              // 状态码
//    u8 processnum = 0;      // 注册步骤（0~4）
//    u8 retry_count = 0;     // 重试计数器（防止超时）
//    
//    printf("开始注册指纹，ID: %d\n", pageID);
//    
//    while(1)
//    {
//        switch(processnum)
//        {
//            case 0: // 第一步：第一次按压指纹
//                retry_count++;
//                printf("请第一次按压指纹...\n");
//                
//                ensure = PS_GetImage();
//                if(ensure == 0x00) 
//                {
//                    ensure = PS_GenChar(CharBuffer1); // 生成特征到缓冲区1
//                    if(ensure == 0x00)
//                    {
//                        printf("第一次按压成功\n");
//                        retry_count = 0;
//                        processnum = 1; // 进入第二步
//                    }
//                    else 
//                    {
//                        printf("第一次生成特征失败: %s\n", EnsureMessage(ensure));
//                    }
//                }
//                else 
//                {
//                    printf("第一次获取图像失败: %s\n", EnsureMessage(ensure));
//                }
//                break;
//            
//            case 1: // 第二步：第二次按压指纹
//                retry_count++;
//                printf("请第二次按压指纹...\n");
//                
//                ensure = PS_GetImage();
//                if(ensure == 0x00) 
//                {
//                    ensure = PS_GenChar(CharBuffer2); // 生成特征到缓冲区2
//                    if(ensure == 0x00)
//                    {
//                        printf("第二次按压成功\n");
//                        retry_count = 0;
//                        processnum = 2; // 进入第三步
//                    }
//                    else 
//                    {
//                        printf("第二次生成特征失败: %s\n", EnsureMessage(ensure));
//                    }
//                }
//                else 
//                {
//                    printf("第二次获取图像失败: %s\n", EnsureMessage(ensure));
//                }
//                break;

//            case 2: // 第三步：对比两次指纹特征
//                printf("对比两次指纹...\n");
//                
//                ensure = PS_Match(); // 比对缓冲区1和2的特征
//                if(ensure == 0x00) 
//                {
//                    printf("对比成功，两次指纹一致\n");
//                    processnum = 3; // 进入第四步
//                }
//                else 
//                {
//                    printf("对比失败，请重新录入指纹: %s\n", EnsureMessage(ensure));
//                    retry_count = 0;
//                    processnum = 0; // 重新开始第一步
//                }
//                delay_ms(1200);
//                break;

//            case 3: // 第四步：生成指纹模板
//                printf("生成指纹模板...\n");
//                
//                ensure = PS_RegModel(); // 合并两个缓冲区特征生成模板
//                if(ensure == 0x00) 
//                {
//                    printf("生成指纹模板成功\n");
//                    processnum = 4; // 进入第五步
//                }
//                else 
//                {
//                    printf("生成模板失败: %s\n", EnsureMessage(ensure));
//                    processnum = 0; // 重新开始
//                }
//                delay_ms(1200);
//                break;
//                
//            case 4: // 第五步：存储指纹模板到指定ID
//                printf("存储指纹到ID: %d\n", pageID);
//                
//                // 检查ID是否超出模块最大容量
//                if(pageID >= AS608Para.PS_max)
//                {
//                    printf("ID超出范围！最大ID: %d\n", AS608Para.PS_max - 1);
//                    return;
//                }
//                
//                ensure = PS_StoreChar(CharBuffer1, pageID); // 存储模板
//                if(ensure == 0x00) 
//                {            
//                    printf("指纹注册成功！ID: %d\n", pageID);
//                    
//                    // 刷新指纹库数量
//                    PS_ValidTempleteNum(&ValidN);
//                    printf("指纹库剩余容量: %d\n", AS608Para.PS_max - ValidN);
//                    
//                    return; // 注册完成
//                }
//                else 
//                {
//                    printf("指纹存储失败: %s\n", EnsureMessage(ensure));
//                    processnum = 0; // 重新开始
//                }
//                break;
//        }
//        
//        // 超过10次重试则超时退出
//        if(retry_count >= 10)
//        {
//            printf("操作超时，注册中止\n");
//            return;
//        }
//        
//        delay_ms(400);
//    }
//}

///**
// * @brief  删除指定ID的指纹
// * @param  pageID：要删除的指纹ID
// */
//void delete_single_FR(u16 pageID)
//{
//    u8 ensure;
//    
//    printf("删除指纹ID: %d\n", pageID);
//    
//    // 尝试删除指定ID的指纹
//    ensure = PS_DeletChar(pageID, 1);  
//    if(ensure == 0x00)
//    {
//        printf("删除指纹ID %d 成功\n", pageID);
//    }
//    else if(ensure == 0x01)  // 0x01通常表示ID不存在
//    {
//        printf("指纹ID %d 不存在，无法删除\n", pageID);
//    }
//    else
//    {
//        printf("删除指纹失败: %s\n", EnsureMessage(ensure));
//    }	
//    
//    // 更新当前指纹数量
//    if(PS_ValidTempleteNum(&ValidN) == 0x00)
//    {
//        printf("当前指纹数量: %d\n", ValidN);
//    }
//}

///**
// * @brief  清空指纹模块中所有已存储的指纹
// */
//void clear_all_FR(void)
//{
//    u8 ensure;
//    u16 valid_num;
//    
//    printf("准备清空所有指纹...\n");
//    
//    // 先获取当前指纹数量
//    ensure = PS_ValidTempleteNum(&valid_num);
//    if(ensure == 0x00 && valid_num > 0)
//    {
//        printf("当前有 %d 个指纹，确认清空吗？\n", valid_num);
//        printf("按按键3确认清空，其他按键取消\n");
//        
//        // 等待用户确认（简化处理：延时3秒）
//        delay_ms(3000);
//        
//        ensure = PS_Empty(); // 清空指纹库
//        if(ensure == 0x00)
//        {
//            printf("清空指纹库成功\n");
//        }
//        else
//        {
//            printf("清空指纹库失败: %s\n", EnsureMessage(ensure));
//        }
//    }
//    else if(valid_num == 0)
//    {
//        printf("指纹库已经是空的\n");
//    }
//    else
//    {
//        printf("读取指纹数量失败: %s\n", EnsureMessage(ensure));
//    }
//}

//// -------------------------- 开锁控制函数 --------------------------
///**
// * @brief  执行开锁具体操作（包含防重复逻辑）
// */
//void execute_unlock_procedure(void)
//{
//    // 检查是否正在开锁（防止重复触发）
//    if(g_lock_operating) {
//        printf("开锁操作正在进行中，跳过本次操作\r\n");
//        return;
//    }
//    
//    g_lock_operating = 1;  // 标记为正在开锁
//    BEEP_ON;               // 蜂鸣器提示
//    delay_ms(100);
//    BEEP_OFF;
//    
//    // 控制锁芯
//    lock_on();     // 开锁
//    delay_ms(1500);
//    lock_off();    // 关锁
//    
//    // 控制舵机（模拟锁舌动作）
//    sg90_angle_set(0);    // 复位到0度
//    delay_ms(500);
//    sg90_angle_set(140);  // 转动到140度（开锁位置）
//    delay_ms(500);
//	
//    g_lock_operating = 0;  // 清除开锁状态
//    printf("开锁操作完成\r\n");
//}

///**
// * @brief  安全开锁函数（增加防频繁触发逻辑）
// */
//void safe_unlock(void)
//{
//    static uint32_t last_unlock_time = 0;  // 上次开锁时间
//    uint32_t current_time = xTaskGetTickCount();  // 当前系统时间（FreeRTOS ticks）
//    
//    // 2秒内不重复开锁（防止误触发）
//    if((current_time - last_unlock_time) < pdMS_TO_TICKS(2000)) {
//        printf("开锁操作过于频繁，忽略本次操作\r\n");
//        return;
//    }
//    
//    last_unlock_time = current_time;  // 更新上次开锁时间
//    execute_unlock_procedure();       // 执行开锁
//}

//// -------------------------- 密码管理函数 --------------------------
///**
// * @brief  初始化密码系统（从Flash读取或设置默认密码）
// */
//void password_init(void)
//{
//    uint8_t flash_data[PASSWORD_LENGTH];
//    // 从Flash读取密码
//    w25q128_read_data(PASSWORD_ADDR, current_password, PASSWORD_LENGTH);
//	
//    printf("Flash原始数据: ");
//    for(int i = 0; i < PASSWORD_LENGTH; i++) {
//        printf("%02X ", flash_data[i]);
//    }
//    printf("\r\n");
//    
//    current_password[PASSWORD_LENGTH] = '\0';  // 添加字符串结束符
//    
//    // 检查是否是首次使用（Flash数据为0xFF或无效）
//    uint8_t is_first_use = 1;
//    for(int i = 0; i < PASSWORD_LENGTH; i++) {
//        if(current_password[i] != 0xFF && current_password[i] >= '0' && current_password[i] <= '9') {
//            is_first_use = 0;  // 非首次使用
//            break;
//        }
//    }
//    
//    if(is_first_use) {
//        // 首次使用：设置默认密码并保存到Flash
//        memcpy(current_password, DEFAULT_PASSWORD, PASSWORD_LENGTH);
//        current_password[PASSWORD_LENGTH] = '\0';
//        w25q128_write_page(PASSWORD_ADDR, current_password, PASSWORD_LENGTH);
//        printf("初始化默认密码: %s\r\n", DEFAULT_PASSWORD);
//    } else {
//        // 确保密码为有效数字
//        for(int i = 0; i < PASSWORD_LENGTH; i++) {
//            if(current_password[i] < '0' || current_password[i] > '9') {
//                current_password[i] = '0';  // 替换无效字符
//            }
//        }
//        current_password[PASSWORD_LENGTH] = '\0';
//        printf("读取密码: %s\r\n", current_password);
//    }
//}

///**
// * @brief  验证输入密码是否正确
// * @param  input_password：输入的密码字符串
// * @return 1：验证成功；0：验证失败
// */
//uint8_t verify_password(const char* input_password)
//{
//    return (memcmp(input_password, current_password, PASSWORD_LENGTH) == 0);
//}

///**
// * @brief  修改密码（需验证旧密码）
// * @param  old_password：旧密码
// * @param  new_password：新密码（6位数字）
// * @return 1：修改成功；0：修改失败
// */
//uint8_t change_password(const char* old_password, const char* new_password)
//{
//    if(verify_password(old_password)) {  // 验证旧密码
//        if(strlen(new_password) != PASSWORD_LENGTH) {  // 检查新密码长度
//            printf("新密码长度错误！\r\n");
//            return 0;
//        }
//        
//        // 擦除Flash扇区（确保数据写入正确）
//        w25q128_erase_sector(PASSWORD_ADDR);
//        delay_ms(50);
//        
//        // 写入新密码
//        w25q128_write_page(PASSWORD_ADDR, (uint8_t*)new_password, PASSWORD_LENGTH);
//        
//        // 更新当前密码缓存
//        memcpy(current_password, new_password, PASSWORD_LENGTH);
//        current_password[PASSWORD_LENGTH] = '\0';
//        
//        printf("密码修改成功: %s\r\n", new_password);
//        return 1;
//    } else {
//        printf("旧密码验证失败！\r\n");
//        return 0;
//    }
//}

///**
// * @brief  获取当前密码用于显示
// * @param  display_buf：输出缓冲区（需至少PASSWORD_LENGTH+1字节）
// */
//void get_password_display(char* display_buf)
//{
//    memcpy(display_buf, current_password, PASSWORD_LENGTH);
//    display_buf[PASSWORD_LENGTH] = '\0';
//}

//// -------------------------- 手机号码管理函数 --------------------------
///**
// * @brief  初始化手机号码（从Flash读取或设置默认值）
// */
//void phone_number_init(void)
//{
//    // 从Flash读取手机号码
//    w25q128_read_data(PHONE_NUMBER_ADDR, (uint8_t*)current_phone_number, PHONE_LENGTH);
//    current_phone_number[PHONE_LENGTH] = '\0';  // 添加结束符
//    
//    // 检查是否是首次使用
//    uint8_t is_first_use = 1;
//    for(int i = 0; i < PHONE_LENGTH; i++) {
//        if(current_phone_number[i] != 0xFF && current_phone_number[i] >= '0' && current_phone_number[i] <= '9') {
//            is_first_use = 0;  // 非首次使用
//            break;
//        }
//    }
//    
//    if(is_first_use) {
//        // 首次使用：设置默认手机号并保存
//        memcpy(current_phone_number, DEFAULT_PHONE, PHONE_LENGTH);
//        current_phone_number[PHONE_LENGTH] = '\0';
//        w25q128_write_page(PHONE_NUMBER_ADDR, (uint8_t*)current_phone_number, PHONE_LENGTH);
//        printf("初始化默认手机号码: %s\r\n", DEFAULT_PHONE);
//    } else {
//        printf("读取手机号码: %s\r\n", current_phone_number);
//    }
//}

///**
// * @brief  验证输入的手机号码是否正确
// * @param  phone_number：输入的手机号码
// * @return 1：验证成功；0：验证失败
// */
//uint8_t verify_phone_number(const char* phone_number)
//{
//    return (memcmp(phone_number, current_phone_number, PHONE_LENGTH) == 0);
//}

///**
// * @brief  修改手机号码
// * @param  new_phone_number：新手机号码（11位数字）
// * @return 1：修改成功；0：修改失败
// */
//uint8_t change_phone_number(const char* new_phone_number)
//{
//    if(strlen(new_phone_number) != PHONE_LENGTH) {  // 检查长度
//        printf("手机号码长度错误！\r\n");
//        return 0;
//    }
//    
//    // 擦除Flash扇区
//    w25q128_erase_sector(PHONE_NUMBER_ADDR);
//    delay_ms(50);
//    
//    // 写入新手机号码
//    w25q128_write_page(PHONE_NUMBER_ADDR, (uint8_t*)new_phone_number, PHONE_LENGTH);
//    
//    // 更新缓存
//    memcpy(current_phone_number, new_phone_number, PHONE_LENGTH);
//    current_phone_number[PHONE_LENGTH] = '\0';
//    
//    printf("手机号码修改成功: %s\r\n", new_phone_number);
//    return 1;
//}

///**
// * @brief  获取当前手机号码用于显示
// * @param  phone_buf：输出缓冲区（需至少PHONE_LENGTH+1字节）
// */
//void get_current_phone_number(char* phone_buf)
//{
//    memcpy(phone_buf, current_phone_number, PHONE_LENGTH);
//    phone_buf[PHONE_LENGTH] = '\0';
//}

//// -------------------------- 卡片管理辅助函数 --------------------------
///**
// * @brief  获取所有已注册卡号并格式化显示
// * @param  display_buf：输出缓冲区
// * @param  buf_size：缓冲区大小
// */
//void get_all_cards_display(char* display_buf, uint16_t buf_size)
//{
//    uint8_t record_card[6];  // 临时存储读取的卡号
//    uint8_t card_count = 0;  // 已注册卡片数量
//    
//    display_buf[0] = '\0';  // 清空缓冲区
//    
//    // 遍历所有可能的存储位置
//    for(uint8_t i = 0; i < CARD_NUM; i++) {
//        w25q128_read_data(CARD_ADDR + i * CARD_SIZE, record_card, CARD_SIZE);
//        
//        if(record_card[0] == 0x55) {  // 前缀0x55表示有效卡号
//            // 格式化卡号字符串
//            char card_str[20];
//            snprintf(card_str, sizeof(card_str), "Card %d: %02X%02X%02X%02X%02X\n", 
//                     card_count + 1, 
//                     record_card[1], record_card[2], record_card[3], 
//                     record_card[4], record_card[5]);
//            
//            // 检查缓冲区是否足够
//            if(strlen(display_buf) + strlen(card_str) < buf_size - 1) {
//                strcat(display_buf, card_str);
//                card_count++;
//            } else {
//                strcat(display_buf, "...\n(More cards)");
//                break;
//            }
//        } else {
//            break;  // 遇到空位置，提前结束
//        }
//    }
//    
//    if(card_count == 0) {
//        strcpy(display_buf, "No cards registered");  // 无卡片时显示
//    }
//}

//// -------------------------- 主函数与任务实现 --------------------------
///**
// * @brief  主函数：初始化系统并启动FreeRTOS调度
// */
//int main()
//{
//    // 中断优先级分组：4位抢占优先级，0位子优先级
//    NVIC_PriorityGroupConfig(NVIC_PriorityGroup_4);
//    
//    // 初始化基础硬件
//    led_init();         // LED初始化
//    beep_init();        // 蜂鸣器初始化
//    key_init();         // 按键初始化
//    lock_init();        // 锁控制初始化
//    uart1_init (9600);  // 串口1初始化（调试用）
//    usart2_init(57600); // 串口2初始化（蓝牙用）
//    
//    // 创建初始化任务（优先级5）
//    xTaskCreate((TaskFunction_t)app_task_init,			/* 任务函数 */
//                (const char *)"app_task_init",			/* 任务名 */
//                (uint16_t)1024,							/* 栈大小 */
//                (void *)NULL,							/* 参数 */
//                (UBaseType_t)5,							/* 优先级 */
//                (TaskHandle_t *)&app_task_init_handle); /* 任务句柄 */

//    // 启动任务调度器
//    vTaskStartScheduler();

//    // 若调度器启动失败，进入死循环
//    while (1);
//}

///**
// * @brief  初始化任务：完成所有硬件和软件初始化，创建其他任务
// * @param  pvParameters：任务参数（未使用）
// */
//void app_task_init(void *pvParameters)
//{
//    printf("app_task_init start!\r\n");
//    
//    // 初始化外设与模块
//    oled_init();               // OLED屏幕初始化
//    esp8266_init(115200);      // ESP8266 WiFi模块初始化
//    get_3days_weather();       // 获取3天天气数据
//    show_weather(0);           // 显示当天天气
//    ia_init();                 // 红外传感器初始化
//    sr04_init();               // 超声波传感器初始化
//    spi1_init ();              // SPI1初始化（用于RC522/W25Q128）
//    MF522_Init();              // RC522 RFID模块初始化
//    sg90_init();               // 舵机初始化
//    rtc_init();                // 实时时钟初始化
//    vibrate_buzzer_init();     // 震动传感器与蜂鸣器初始化
//    lock_433m_init();          // 433M模块初始化
//    password_init();           // 密码系统初始化
//    phone_number_init();       // 手机号码初始化
//    
//    // 指纹模块初始化
//    PS_StaGPIO_Init();  // 指纹模块GPIO初始化
//    
//    // 与AS608指纹模块握手（建立通信）
//    while(PS_HandShake(&AS608Addr))// 握手失败则重试
//    {
//        delay_ms(400);
//        printf("尝试连接模块\r\n");
//        delay_ms(800);
//    }
//    printf("握手成功\r\n");
//    
//    // 读取指纹模块系统参数
//    printf("读取系统参数...\r\n");
//    u8 ensure = PS_ReadSysPara(&AS608Para);
//    if(ensure == 0x00)
//    {
//        printf("系统参数读取成功！\r\n");
//        printf("指纹库最大容量: %d\r\n", AS608Para.PS_max);
//        printf("安全等级: %d\r\n", AS608Para.PS_level);
//        printf("波特率: %d\r\n", AS608Para.PS_N * 9600);
//    }
//    else
//    {
//        printf("系统参数读取失败: %s\r\n", EnsureMessage(ensure));
//        AS608Para.PS_max = 300; // 失败时使用默认值
//        printf("使用默认容量: %d\r\n", AS608Para.PS_max);
//    }

//    // 读取当前指纹数量
//    ensure = PS_ValidTempleteNum(&ValidN);
//    if(ensure == 0x00)
//    {
//        printf("当前指纹数量: %d\r\n", ValidN);
//    }
//	
//    // 创建消息队列（存储蓝牙接收数据）
//    usart_queue = xQueueCreate(QUEUE_SIZE, sizeof(usart_rx_buf));
//    
//    // 创建二值信号量（433M模块触发开锁）
//    lock_433m_sem_exit = xSemaphoreCreateBinary();// 初始值为0
//    
//    // 创建互斥锁（保护共享资源）
//    oled_mutex = xSemaphoreCreateMutex();
//    vibrate_mutex = xSemaphoreCreateMutex();
//    
//    // 临界区中创建其他任务（防止任务创建被打断）
//    taskENTER_CRITICAL();

//    // 创建任务1（天气切换与模式控制，优先级6）
//    xTaskCreate((TaskFunction_t)app_task_1, "app_task_1", 512, NULL, 6, &app_task_1_handle);
//    // 创建任务2（环境监测，优先级6）
//    xTaskCreate((TaskFunction_t)app_task_2, "app_task_2", 512, NULL, 6, &app_task_2_handle);
//    // 创建任务3（卡片识别，优先级6）
//    xTaskCreate((TaskFunction_t)app_task_3, "app_task_3", 512, NULL, 6, &app_task_3_handle);
//    // 创建任务4（蓝牙控制，优先级7）
//    xTaskCreate((TaskFunction_t)app_task_4, "app_task_4", 512, NULL, 7, &app_task_4_handle);
//    // 创建任务5（LVGL界面，优先级7）
//    xTaskCreate((TaskFunction_t)app_task_5, "app_task_5", 2048, NULL, 7, &app_task_5_handle);
//    // 创建任务6（433M开锁，优先级6）
//    xTaskCreate((TaskFunction_t)app_task_6, "app_task_6", 512, NULL, 6, &app_task_6_handle);
//    
//    taskEXIT_CRITICAL();  // 退出临界区

//    // 初始化任务完成，删除自身
//    vTaskDelete(NULL);
//}

///**
// * @brief  任务1：天气切换、模式切换（按键控制）
// * @param  pvParameters：任务参数（未使用）
// */
//void app_task_1(void *pvParameters)
//{
//    uint8_t key_num = 0;  // 按键值
//    uint8_t day = 0;      // 天气显示天数（0-2）
//    while(1)
//    {
//        key_num = key_scan();  // 扫描按键
//        if(key_num == 1)        // 按键1：切换显示未来3天天气
//        {
//            taskENTER_CRITICAL();  // 临界区保护
//            day++;
//            day %= 3;
//            show_weather(day);
//            delay_ms(3000);
//            taskEXIT_CRITICAL();
//        }
//        else if(key_num == 2)   // 按键2：更新天气数据
//        {
//            taskENTER_CRITICAL();
//            printf("更新天气...\r\n");
//            get_3days_weather();
//            show_weather(0);
//            day = 0;
//            taskEXIT_CRITICAL();
//        }
//        else if(key_num == 3)   // 按键3：切换到卡片注册模式
//        {
//            taskENTER_CRITICAL();
//            g_mode = MODE_REGISTER;
//            printf("按键3按下，切换到注册模式\r\n");
//            oled_fill(0x00);  // 清屏
//            oled_show_string(0, 0, "Mode: Register",16);  // 显示模式
//            taskEXIT_CRITICAL();
//        }
//        else if(key_num == 4)   // 按键4：切换到卡片清空模式
//        {
//            taskENTER_CRITICAL();
//            g_mode = MODE_CLEAR;
//            printf("按键4按下，准备清空所有卡号\r\n");
//            oled_fill(0x00);
//            oled_show_string(0, 0, "Mode: Clear",16);
//            taskEXIT_CRITICAL();
//        }
//        
//        vTaskDelay(100);  // 延时100ms，释放CPU
//    }
//}

///**
// * @brief  任务2：环境监测（红外/超声波/震动传感器）
// * @param  pvParameters：任务参数（未使用）
// */
//void app_task_2(void *pvParameters)
//{
//    static uint32_t last_trigger_time = 0;  // 上次人体感应触发时间
//    static uint32_t last_vibrate_time = 0;  // 上次震动触发时间
//    int dis = 0;  // 超声波检测距离（cm）
//    while(1)
//    {
//        dis = get_distance();  // 获取距离
//        
//        // 红外感应到人体 或 距离<=10cm，且2秒内未重复触发
//        if(ia_flag_get() == TRUE || (dis <= 10) && (xTaskGetTickCount() - last_trigger_time) > 2000 )
//        {
//            // 申请OLED互斥锁（防止多任务同时操作屏幕）
//            if(xSemaphoreTake(oled_mutex, pdMS_TO_TICKS(10)) == pdTRUE) {
//                // 显示"欢迎回家"
//                oled_fill(0x00);
//                oled_show_chinese(32, 3, 13);
//                oled_show_chinese(48, 3, 14);
//                oled_show_chinese(64, 3, 15);
//                oled_show_chinese(80, 3, 16);
//                delay_ms (500);
//                ia_flag_set (FALSE);  // 清除红外触发标志
//                last_trigger_time = xTaskGetTickCount();
//                show_weather(0);  // 恢复显示天气
//                
//                xSemaphoreGive(oled_mutex);  // 释放互斥锁
//            }
//        }
//        
//        // 震动传感器触发，且2秒内未重复触发
//        if (vibrate_flag_get () == TRUE_VIBRATE && (xTaskGetTickCount() - last_vibrate_time) > 2000)
//        {
//            // 申请震动互斥锁（防止报警冲突）
//            if(xSemaphoreTake(vibrate_mutex, pdMS_TO_TICKS(100)) == pdTRUE) {
//                printf("beep \r\n");
//                play_middle_notes_once();  // 播放报警音乐
//                vibrate_flag_set (FALSE_VIBRATE);  // 清除震动标志
//                last_vibrate_time = xTaskGetTickCount();
//                
//                xSemaphoreGive(vibrate_mutex);  // 释放互斥锁
//            }
//        }

//        vTaskDelay(100);  // 延时100ms
//    }
//}

///**
// * @brief  任务3：卡片识别与管理（注册/验证/清空）
// * @param  pvParameters：任务参数（未使用）
// */
//void app_task_3(void *pvParameters)
//{
//    char card_line1[20], card_line2[20];  // 卡号显示字符串
//    uint8_t status;  // RC522操作状态
//    uint8_t i;       // 循环变量
//    uint8_t verify_success = 0;  // 验证结果标志
//    
//    printf("卡管理任务启动\r\n");
//    
//    while(1)
//    {
//        // 处理清空模式：删除所有已注册卡片
//        if (g_mode == MODE_CLEAR) {
//            BEEP_ON;
//            delay_ms(50);
//            BEEP_OFF;
//            printf("进入清空模式，正在删除所有卡号...\r\n");
//            
//            w25q128_erase_sector(CARD_ADDR);  // 擦除卡片存储扇区
//            
//            printf("所有卡号已清空\r\n");
//            oled_show_string(0, 2, "Empty ok",16);
//            g_mode = MODE_VERIFY;  // 回到验证模式
//            oled_fill(0x00);
//            oled_show_string(0, 0, "Mode: verify ",16);
//            vTaskDelay(1000);
//            continue;
//        }
//        
//        printf("当前模式: %d (0=验证, 1=注册)\r\n", g_mode);
//        
//        MF522_Init();  // 初始化RC522
//        
//        // 1. 请求卡片（检测是否有卡片靠近）
//        status = MFRC522_Request(PICC_REQALL, card_type);
//        if(status != MI_OK){
//            printf("未检测到卡片...\r\n");
//            vTaskDelay(1000);
//            continue;
//        }
//        
//        // 2. 防碰撞检测（获取唯一卡号）
//        status = MFRC522_Anticoll(card_id);
//        if(status != MI_OK){
//            printf("防碰撞失败!\r\n");
//            vTaskDelay(1000);
//            continue;
//        }
//        
//        MFRC522_SelectTag(card_id);  // 选中卡片
//        
//        // 格式化卡号字符串（分两行显示）
//        sprintf(card_line1, "ID:%02X%02X%02X%02X", card_id[1], card_id[2], card_id[3], card_id[4]);
//        sprintf(card_line2, "%02X", card_id[5]);
//        
//        // 打印卡号
//        printf("检测到卡号: %02X%02X%02X%02X%02X\r\n",
//               card_id[1], card_id[2], card_id[3], card_id[4], card_id[5]);
//        
//        // 3. 验证模式：检查卡号是否已注册
//        if(g_mode == MODE_VERIFY) {
//            verify_success = 0;
//            printf("进入验证模式...\r\n");
//            
//            // 遍历所有存储位置，查找匹配卡号
//            for(i = 0; i < CARD_NUM; i++) {
//                w25q128_read_data(CARD_ADDR + i * CARD_SIZE, record_card, CARD_SIZE);
//                
//                // 前缀0x55且卡号匹配
//                if(record_card[0] == 0x55 && memcmp(record_card + 1, card_id + 1, 5) == 0) {
//                    verify_success = 1;
//                    break;
//                }
//            }
//            
//            // 验证结果处理
//            if(verify_success) {
//                printf("验证成功！该卡已注册\r\n");
//                taskENTER_CRITICAL();
//                safe_unlock();  // 执行开锁
//                oled_fill(0x00);
//                oled_show_string(0, 0, "Card: ID",16);
//                oled_show_string(0, 2, card_line1, 16);
//                oled_show_string(0, 4, card_line2, 16);
//                oled_show_chinese(32, 5, 13);  // 显示"欢迎回家"
//                oled_show_chinese(48, 5, 14);
//                oled_show_chinese(64, 5, 15);
//                oled_show_chinese(80, 5, 16);
//                delay_ms (500);
//                
//                // 舵机动作
//                sg90_angle_set(0);
//                delay_ms(500);
//                sg90_angle_set(140);
//                delay_ms(500);
//                
//                taskEXIT_CRITICAL();
//            } else {
//                printf("验证失败！该卡未注册\r\n");
//                BEEP_ON;
//                delay_ms(1000);
//                BEEP_OFF;
//            }
//        }
//        // 4. 注册模式：新增卡号到Flash
//        else if(g_mode == MODE_REGISTER) {
//            printf("进入注册模式...\r\n");
//            uint8_t registered = 0;    // 是否已注册标志
//            uint8_t empty_index = 0xFF;// 第一个空存储位置
//            
//            // 查找空位置和检查是否已注册
//            for(i = 0; i < CARD_NUM; i++) {
//                w25q128_read_data(CARD_ADDR + i * CARD_SIZE, record_card, CARD_SIZE);
//                
//                // 检查是否已注册
//                if(record_card[0] == 0x55 && memcmp(record_card + 1, card_id + 1, 5) == 0) {
//                    registered = 1;
//                    break;
//                }
//                
//                // 记录第一个空位置
//                if(record_card[0] != 0x55 && empty_index == 0xFF) {
//                    empty_index = i;
//                }
//            }
//            
//            // 处理注册逻辑
//            if(registered) {
//                printf("注册失败！该卡已注册\r\n");
//                // 双重蜂鸣提示
//                BEEP_ON;
//                delay_ms(1000);
//                BEEP_OFF;
//                delay_ms(500);
//                BEEP_ON;
//                delay_ms(1000);
//                BEEP_OFF;
//            } else if(empty_index != 0xFF) {
//                // 添加前缀0x55并写入Flash
//                card_id[0] = 0x55;
//                w25q128_write_page(CARD_ADDR + empty_index * CARD_SIZE, card_id, CARD_SIZE);
//                printf("注册成功！已保存卡号\r\n");
//                
//                oled_show_string(0, 2, "Register ok",16);
//                oled_fill(0x00);
//                oled_show_string(0, 0, "Mode: verify ",16);
//                
//                // 短声提示成功
//                BEEP_ON;
//                delay_ms(100);
//                BEEP_OFF;
//                delay_ms(100);
//                BEEP_ON;
//                delay_ms(100);
//                BEEP_OFF;
//            } else {
//                printf("注册失败！已达到最大注册数量(%d张)\r\n", CARD_NUM);
//                oled_show_string(0, 2, "Register fault",16);
//                BEEP_ON;
//                delay_ms(3000);
//                BEEP_OFF;
//            }
//            
//            g_mode = MODE_VERIFY;  // 回到验证模式
//        }
//        
//        vTaskDelay(100);  // 延时100ms
//    }
//}

///**
// * @brief  任务4：蓝牙指令接收与处理
// * @param  pvParameters：任务参数（未使用）
// */
//void app_task_4(void *pvParameters)
//{
//    printf("task 4 \r\n");
//    usart_rx_buf task_rx_buf;  // 蓝牙接收数据缓冲区
//    char ascii_buf[64];        // ASCII转换缓冲区（处理中文乱码）
//    
//    while(1)
//    {
//        // 等待消息队列中的蓝牙数据（阻塞等待）
//        xQueueReceive(usart_queue, &task_rx_buf, portMAX_DELAY);
//        
//        // UTF-8转ASCII（忽略中文等多字节字符）
//        int j = 0;
//        for(int i = 0; i < strlen((char*)task_rx_buf.uart_buf) && j < sizeof(ascii_buf)-1; i++) {
//            if((task_rx_buf.uart_buf[i] & 0x80) == 0) {  // 单字节ASCII字符
//                ascii_buf[j++] = task_rx_buf.uart_buf[i];
//            }
//        }
//        ascii_buf[j] = '\0';
//        
//        // 打印调试信息
//        printf("原始数据: ");
//        for(int i = 0; i < strlen((char*)task_rx_buf.uart_buf); i++) {
//            printf("%02X ", task_rx_buf.uart_buf[i]);
//        }
//        printf("\r\n");
//        printf("转换后: %s\r\n", ascii_buf);
//        
//        // 解析指令
//        if(strstr(ascii_buf, "ledon")){         // LED打开
//            printf("LED ON命令!\r\n");
//            PFout(10) = 0;
//        }
//        else if(strstr(ascii_buf, "ledoff")){   // LED关闭
//            printf("LED OFF命令!\r\n");
//            PFout(10) = 1;
//        }
//        else if(strstr(ascii_buf, "open_clok")){// 开锁
//            taskENTER_CRITICAL();
//            safe_unlock();
//            oled_fill(0x00);			   
//            oled_show_chinese(32, 4, 13);  // 欢迎回家
//            oled_show_chinese(48, 4, 14);
//            oled_show_chinese(64, 4, 15);
//            oled_show_chinese(80, 4, 16);
//            delay_ms (500);
//            
//            // 舵机动作
//            sg90_angle_set(0);
//            delay_ms(500);
//            sg90_angle_set(140);
//            delay_ms(500);
//            
//            taskEXIT_CRITICAL();
//        }
//        else if(strstr((char *)task_rx_buf.uart_buf,"weather")){// 显示天气
//            show_weather(0);
//        }
//        else{
//            printf("unknow command!\n");  // 未知指令
//        }
//        
//        vTaskDelay(100);  // 延时100ms
//    }
//}

///**
// * @brief  任务5：LVGL图形界面刷新
// * @param  pvParameters：任务参数（未使用）
// */
//void app_task_5(void *pvParameters)
//{
//    printf("=== LVGL任务开始 ===\r\n");
//	
//    lv_init();  // 初始化LVGL库
//    lv_port_disp_init();  // 初始化显示接口
//    lv_port_indev_init();  // 初始化输入设备（触摸屏）

//    // 触摸屏校准（如需校准可开启）
//#if 0
//	LCD_Clear(WHITE);
//	TP_Adjust();
//	TP_Save_Adjdata();
//#endif
//	
//    ui_init();  // 初始化自定义UI界面
//	
//    while(1){
//        tp_dev.scan(0);  // 扫描触摸屏
//        
//        // 非阻塞方式获取OLED互斥锁，刷新LVGL界面
//        if(xSemaphoreTake(oled_mutex, 0) == pdTRUE) {
//            lv_task_handler();  // LVGL核心处理函数
//            xSemaphoreGive(oled_mutex);
//        } else {
//            lv_task_handler();  // 即使获取不到锁也处理（保证触摸响应）
//        }
//        vTaskDelay(5);  // 短延时，提高界面流畅度
//    }	
//}

///**
// * @brief  任务6：433M无线信号处理（触发开锁）
// * @param  pvParameters：任务参数（未使用）
// */
//void app_task_6(void *pvParameters)
//{
//    static uint32_t last_433m_time = 0;  // 上次433M触发时间
//    
//    while(1){
//        // 等待433M信号量（阻塞等待）
//        xSemaphoreTake(lock_433m_sem_exit, portMAX_DELAY);
//        
//        // 检查2秒内是否重复触发
//        uint32_t current_time = xTaskGetTickCount();
//        if((current_time - last_433m_time) < pdMS_TO_TICKS(2000)) {
//            printf("433M信号重复触发，忽略本次操作\r\n");
//            continue;
//        }
//        
//        last_433m_time = current_time;  // 更新触发时间
//        taskENTER_CRITICAL();
//        
//        printf("433M signal received, unlocking...\r\n");
//        safe_unlock();  // 执行开锁
//        
//        // OLED显示欢迎信息
//        oled_fill(0x00);
//        oled_show_chinese(32, 4, 13);
//        oled_show_chinese(48, 4, 14);
//        oled_show_chinese(64, 4, 15);
//        oled_show_chinese(80, 4, 16);
//        
//        // 舵机动作
//        sg90_angle_set(0);
//        delay_ms(500);
//        sg90_angle_set(140);
//        delay_ms(500);
//        
//        taskEXIT_CRITICAL();
//        
//        vTaskDelay(100);  // 延时100ms
//    }
//}

///**
// * @brief  FreeRTOS心跳钩子函数（用于LVGL计时）
// * @note   每1ms调用一次，提供LVGL所需的系统时间
// */
//void vApplicationTickHook(void)
//{
//    lv_tick_inc(1);  // LVGL计时递增1ms
//}